1
2
Nästa
I de enklaste termerna gör git pull en git-hämtning följt av en git-sammanslagning.
Du kan göra en git-hämtning när som helst för att uppdatera dina fjärrspårningsgrenar under refs / remotes / /.
Denna operation ändrar aldrig några av dina egna lokala filialer under referenser / huvuden, och det är säkert att göra utan att ändra din arbetskopia. Jag har till och med hört talas om människor som kör git-hämtning regelbundet i ett cron-jobb i bakgrunden (även om jag inte skulle rekommendera att göra detta).
En git pull är vad du skulle göra för att göra en lokal filial uppdaterad med sin fjärrversion, samtidigt som du uppdaterar dina andra fjärrspårningsgrenar.
Från Git-dokumentationen för git pull:
I sitt standardläge är git pull förkortning för git-hämtning följt av git merge FETCH_HEAD.
|
När du använder pull försöker Git automatiskt göra ditt arbete åt dig. Det är kontextkänsligt, så Git kommer att slå samman alla dragna åtaganden i den gren du arbetar för närvarande. Pull slår samman åtaganden automatiskt utan att du kan granska dem först. Om du inte hanterar dina filialer noggrant kan du stöta på frekventa konflikter.
När du hämtar samlar Git alla åtaganden från målgrenen som inte finns i din nuvarande gren och lagrar dem i ditt lokala förråd. Det slår emellertid inte samman dem med din nuvarande gren. Detta är särskilt användbart om du behöver hålla ditt förråd uppdaterat, men arbetar med något som kan gå sönder om du uppdaterar dina filer.
För att integrera åtagandena i din huvudfilial använder du merge.
|
Det är viktigt att kontrastera gitts designfilosofi med filosofin för ett mer traditionellt källkontrollverktyg som SVN.
Subversion designades och byggdes med en klient / servermodell. Det finns ett enda arkiv som är servern, och flera klienter kan hämta kod från servern, arbeta med den och sedan överföra den till servern. Antagandet är att klienten alltid kan kontakta servern när den behöver utföra en operation.
Git designades för att stödja en mer distribuerad modell utan behov av ett centralt arkiv (men du kan säkert använda en om du vill). Git designades också så att klienten och "servern" inte behöver vara online samtidigt. Git designades så att människor på en opålitlig länk kunde utbyta kod via e-post, till och med. Det är möjligt att arbeta helt frånkopplad och bränna en CD för att utbyta kod via git.
För att stödja den här modellen upprätthåller git ett lokalt arkiv med din kod och även ett ytterligare lokalt arkiv som speglar tillståndet för fjärrlagret. Genom att hålla en kopia av fjärrförvaret lokalt kan git ta reda på de ändringar som behövs även när fjärrförvaret inte kan nås. Senare när du behöver skicka ändringarna till någon annan kan git överföra dem som en uppsättning ändringar från en tidpunkt som är känd till fjärrförvaret.
git fetch är kommandot som säger "uppdatera min lokala kopia av fjärrförvaret."
git pull säger "ta med ändringarna i fjärrförvaret där jag behåller min egen kod."
Normalt gör git pull detta genom att göra en git-hämtning för att uppdatera den lokala kopian av fjärrförvaret och sedan slå samman ändringarna i ditt eget kodförvar och eventuellt din arbetskopia.
Att ta bort är att komma ihåg att det ofta finns minst tre kopior av ett projekt på din arbetsstation. En kopia är ditt eget arkiv med din egen åtagandeshistorik. Den andra kopian är din arbetskopia där du redigerar och bygger. Den tredje kopian är din lokala "cachade" kopia av ett fjärrlager.
|
Här är Oliver Steeles bild av hur allt det här passar ihop:
Om det finns tillräckligt intresse antar jag att jag kan uppdatera bilden för att lägga till git-klon och git-sammanslagning ...
|
Ett användningsfall för git-hämtning är att följande kommer att berätta om eventuella förändringar i fjärrgrenen sedan din senaste dragning ... så att du kan kontrollera innan du gör en faktisk dragning, vilket kan ändra filer i din nuvarande gren och arbetskopia.
git hämta
git diff ... ursprung
Se: https://git-scm.com/docs/git-diff angående dubbel- och trippelpunktssyntax i diff-kommandot
|
Det kostade mig lite att förstå vad som var skillnaden, men det här är en enkel förklaring. mästare i din lokala värd är en gren.
När du klonar ett förråd hämtar du hela förvaret till din lokala värd. Det betyder att du vid den tiden har ett ursprung / masterpekare till HEAD och master som pekar på samma HEAD.
när du börjar arbeta och gör åtaganden flyttar du huvudpekaren till HEAD + dina åtaganden. Men ursprung / huvudpekaren pekar fortfarande på vad det var när du klonade.
Så skillnaden blir:
Om du gör en git-hämtning kommer den bara att hämta alla ändringar i fjärrförvaret (GitHub) och flytta origin / master-pekaren till HEAD. Under tiden kommer din lokala filialmästare att peka på vart den har.
Om du gör en git pull kommer det i princip att hämta (som förklarats tidigare) och slå samman alla nya ändringar till dinhuvudgren och flytta pekaren till HEAD.
|
Ibland hjälper en visuell representation.
|
I korthet
git hämtar liknar pull men går inte ihop. dvs det hämtar fjärruppdateringar (refs och objekt) men din lokala förblir densamma (dvs ursprung / master uppdateras men master förblir densamma).
git pull drar ner från en fjärrkontroll och smälter omedelbart.
Mer
git klon kloner en repo.
git rebase sparar saker från din nuvarande gren som inte finns i uppströmsgrenen till ett tillfälligt område. Din filial är nu densamma som innan du startade dina ändringar. Så, git pull -rebase kommer att dra ner fjärrändringarna, spola tillbaka din lokala filial, spela upp dina ändringar över toppen av din nuvarande gren en efter en tills du är uppdaterad.
Dessutom kommer git branch -a att visa dig exakt vad som händer med alla dina filialer - lokala och avlägsna.
Det här blogginlägget var användbart:
Skillnaden mellan git pull, git fetch och git clone (och git rebase) - Mike Pearce
och täcker git pull, git fetch, git clone och git rebase.
====
UPPDATERING
Jag tänkte att jag skulle uppdatera detta för att visa hur du faktiskt skulle använda detta i praktiken.
Uppdatera din lokala repo från fjärrkontrollen (men slå inte ihop):
git hämta
Efter att ha laddat ner uppdateringarna, låt oss se skillnaderna:
git diff master origin / master
Om du är nöjd med dessa uppdateringar, slå sedan ihop:
git pull
Anmärkningar:
På steg 2: För mer information om skillnader mellan lokala och fjärrkontroller, se: Hur man jämför en lokal gitfilial med sin avlägsna gren?
På steg 3: Det är förmodligen mer exakt (t.ex. på en snabbt föränderlig repo) att göra ett git rebase-ursprung här. Se @Justin Ohms kommentar i ett annat svar.
Se även: http://longair.net/blog/2009/04/16/git-fetch-and-merge/
|
git-pull - Hämta från och slå ihop med ett annat arkiv eller en lokal filial
SYNOPSIS
git pull ...
BESKRIVNING
Kör git-fetch med angivna parametrar och kallar git-merge för att slå samman
hämtat huvud (ar) till den aktuella grenen. Med --rebase, kallar git-rebase
istället för git-merge.
Observera att du kan använda. (aktuell katalog) som att dra
från det lokala förvaret - detta är användbart när du slår samman lokala filialer
in i den nuvarande filialen.
Observera också att alternativen är avsedda för git-pull själv och underliggande git-merge
måste ges innan alternativen som är avsedda för git-fetch.
Du skulle dra om du vill att historierna ska sammanfogas, du skulle hämta om du bara vill ha kodz eftersom någon har taggat några artiklar här.
|
Du kan hämta från ett fjärrförvar, se skillnaderna och sedan dra eller slå ihop.
Detta är ett exempel på ett fjärrförvar som heter origin och en gren som heter master spårar fjärrgrenens origin / master:
git checkout master
git hämta
git diff ursprung / master
git rebase origin master
|
Det korta och enkla svaret är att git pull är helt enkelt git-hämtning följt av git merge.
Det är mycket viktigt att notera att git pull automatiskt slås samman om du gillar det eller inte. Detta kan naturligtvis leda till sammanslagna konflikter. Låt oss säga att din fjärrkontroll är ursprung och din gren är mästare. Om du skickar diff origin / master innan du drar, borde du ha en uppfattning om potentiella sammanslagningskonflikter och kan förbereda din lokala filial därefter.
Förutom att dra och trycka involverar vissa arbetsflöden git rebase, som den här, som jag omformulerar från den länkade artikeln:
git pull origin master
git kassan foo-gren
git rebase master
git push-ursprung foo-gren
Om du befinner dig i en sådan situation kan du bli frestad att skämma bort. Om du inte riktigt, verkligen vet vad du gör, skulle jag rekommendera det. Den här varningen kommer från man-sidan för git-pull, version 2.3.5:
Detta är ett potentiellt farligt driftsätt. Det skrivs om
historia, vilket inte lovar bra när du publicerade den historiken
redan. Använd inte det här alternativet om du inte har läst git-rebase (1)
försiktigt.
|
OK, här är lite information om git pull och git-hämtning, så att du kan förstå de faktiska skillnaderna ... med få enkla ord får hämtning de senaste uppgifterna, men inte kodändringar och kommer inte att röra med din nuvarande lokala filialkod , men dra för att få kodändringarna och slå ihop din lokala filial, läs vidare för att få mer information om var och en:
git hämta
Den laddar ner alla refs och objekt och eventuella nya filialer till ditt lokala arkiv ...
Hämta filialer och / eller taggar (tillsammans "refs") från en eller flera
andra förvar, tillsammans med de föremål som är nödvändiga för att slutföra deras
historier. Fjärrspårningsgrenar uppdateras (se beskrivningen
nedan för sätt att kontrollera detta beteende).
Som standard är alla taggar som pekar in i historiken som hämtas
också hämtad; effekten är att hämta taggar som pekar på grenar som
du är intresserad av. Det här standardbeteendet kan ändras med hjälp av
alternativen --tags eller --no-tags eller genom att konfigurera
fjärr..tagOpt. Genom att använda en refspec som hämtar taggar uttryckligen,
du kan hämta taggar som inte pekar i grenar du är intresserad av
in också.
git hämta kan hämta frånantingen ett enda förvar eller en URL, eller
från flera förråd samtidigt om det ges och det finns ett
fjärrkontroller. post i konfigurationsfilen. (Se git-config1).
När ingen fjärrkontroll har angetts är standardfjärrkontrollen som standard
används, såvida det inte finns en uppströms gren konfigurerad för strömmen
gren.
Namnen på refs som hämtas tillsammans med objektnamnen
de pekar på, skrivs till .git / FETCH_HEAD. Denna information kan vara
används av skript eller andra git-kommandon, som git-pull.
git pull
Det kommer att tillämpa ändringarna från fjärrkontrollen till den aktuella filialen i lokal ...
Inkluderar ändringar från ett fjärrförvar till den aktuella grenen.
I sitt standardläge är git pull förkortning för git-hämtning följt av
git merge FETCH_HEAD.
Mer exakt, git pull kör git-hämtning med angivna parametrar och
kallar git merge för att slå samman de hämtade grenhuvudena i strömmen
gren. Med --rebase körs git rebase istället för git merge.
bör vara namnet på ett fjärrförvar som skickas till
git-fetch1. kan namnge en godtycklig fjärrref (till exempel
namnet på en tagg) eller till och med en samling refs med motsvarande
fjärrspårningsgrenar (t.ex. refs / heads /: refs / remotes / origin /),
men vanligtvis är det namnet på en gren i fjärrförvaret.
Standardvärden för och läses från
"fjärr" och "sammanfoga" -konfiguration för den aktuella grenen enligt inställningen
git-branch - spår.
Jag skapar också det visuella nedan för att visa dig hur git hämtar och git drar ihop ...
|
Denna interaktiva grafiska framställning är till stor hjälp för att underskatta git: http://ndpsoftware.com/git-cheatsheet.html
git hämtar bara "nedladdningar" ändringarna från fjärrkontrollen till ditt lokala arkiv. git pull hämtar ändringarna och slår samman dem i din nuvarande gren. "I standardläget är git pull förkortning för git-hämtning följt av git merge FETCH_HEAD."
|
Bonus:
När jag talar om pull & fetch i ovanstående svar vill jag dela ett intressant trick,
git pull --avstånd
Det här kommandot är det mest användbara kommandot i mitt git-liv som sparar mycket tid.
Innan du trycker på dina nya åtaganden till servern, prova det här kommandot och det synkroniseras automatiskt de senaste serverändringarna (med en hämtning + sammanslagning) och placerar ditt engagemang högst upp i git-loggen. Du behöver inte oroa dig för manuell dragning / sammanslagning.
Hitta detaljer på: http://gitolite.com/git-pull--rebase
|
Jag gillar att ha en visuell representation av situationen för att förstå dessa saker. Kanske andra utvecklare skulle vilja se det också, så här är mitt tillägg. Jag är inte helt säker på att allt är korrekt, så kommentera om du hittar några misstag.
LOKALT SYSTEM
. ===================================================== ===
==================. ====================================================
FJÄRRFÖRVARING. FJÄRRFÖRVARING LOKAL FÖRVARING ARBETSKOPIERA
(ORIGIN). (CACHED)
till exempel, . spegel av
en github repo. . fjärranslutning
Kan också vara .
flera repor.
.
.
FETCH * ------------------> *
Din lokala cache på fjärrkontrollen uppdateras med ursprunget (eller flera
externa källor, det är gits distribuerade natur)
.
DRA *------------------------------------------------ --------> *
ändringar slås samman direkt i din lokala kopia. när konflikter uppstår,
du blir ombedd att fatta beslut.
.
ÅTAGA * <--------------- *
När du kommer från till exempel subversion kan du tro att det är ett engagemang
kommer att uppdatera ursprunget. I git görs en förpliktelse endast till din lokala repo.
.
PUSH * <--------------------------------------- *
Synkroniserar dina ändringar tillbaka till ursprunget.
Några stora fördelar med att ha en hämtad spegel på fjärrkontrollen är:
Prestanda (bläddra igenom alla åtaganden och meddelanden utan att försöka pressa det genom nätverket)
Feedback om läget för din lokala repo (till exempel använder jag Atlassian's SourceTree, vilket kommer att ge mig en glödlampa som indikerar om jag åtar mig framåt eller bakom jämfört med ursprunget. Denna information kan uppdateras med en GIT FETCH).
|
Jag har också kämpat med detta. Jag kom faktiskt hit med en google-sökning av exakt samma fråga. När jag läste alla dessa svar målade jag äntligen en bild i mitt huvud och jag bestämde mig för att försöka få ner den här när jag tittade på tillståndet för de 2 förvaren och en sandlåda och åtgärder som utförts över tiden medan jag tittade på versionen av dem. Så här är vad jag kom på. Korrigera mig om jag trasslat någonstans.
De tre reporna med en hämtning:
--------------------- ----------------------- ------ -----------------
- Remote Repo - - Remote Repo - - Remote Repo -
- - blir knuffad - - -
- @ R01 - - @ R02 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------------------------------
- Lokal repo - - Lokal repo - - Lokal repo -
- dra - - - - hämta -
- @ R01 - - @ R01 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Lokal sandlåda - - Lokal sandlåda - - Lokal sandlåda -
- Kassa - - nytt arbete gjort - - -
- @ R01 - - @ R01 + - - @ R01 + -
--------------------- ----------------------- ------ -----------------
De tre reporna med ett drag
--------------------- ----------------------- ------ -----------------
- Remote Repo - - Remote Repo - - Remote Repo -
- - blir knuffad - - -
- @ R01 - - @ R02 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Lokal repo - - Lokal repo - - Lokal repo -
- dra - - - - dra -
- @ R01 - - @ R01 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Lokal sandlåda - - Lokal sandlåda - - Lokal sandlåda -
- Kassa - - nytt arbete gjort - - slogs ihop med R02 -
- @ R01 - - @ R01 + - - @ R02 + -
--------------------- ----------------------- ------ -----------------
Detta hjälpte mig att förstå varför en hämtning är ganska viktig.
|
Skillnaden mellan GIT Fetch och GIT Pull kan förklaras med följande scenario:
(Med tanke på att bilder talar högre än ord !, har jag tillhandahållit bildföreställning)
Låt oss ta ett exempel på att du arbetar med ett projekt med dina teammedlemmar. Så det kommer att finnas en huvudgren av projektet och alla bidragsgivare måste dela den till sin egen lokala databas och sedan arbeta på den här lokala grenen för att modifiera / lägga till moduler och sedan trycka tillbaka till huvudgrenen.
Så,
Initialt tillstånd för de två grenarna när du gafflade huvudprojektet i ditt lokala förvar kommer att vara så här - (A, B och C är redan moduler slutförda av projektet)
Nu har du börjat arbeta med den nya modulen (antag att D) och när du har slutfört D-modulen vill du driva den till huvudgrenen, men under tiden är det som händer att en av dina lagkamrater har utvecklat ny modul E, F och modifierad C.
Så vad som nu har hänt är att ditt lokala förvar saknas bakom den ursprungliga utvecklingen av projektet och därmed kan du trycka på dina ändringar i huvudgrenen leda till konflikt och kan orsaka att din modul D inte fungerar.
För att undvika sådana problem och att arbeta parallellt med den ursprungliga utvecklingen av projektet finns det två sätt:
1. Git Fetch- Detta hämtar alla ändringar som har gjorts i ursprung / huvudfilialprojektet som inte finns i din lokala filial. Och väntar på att kommandot Git Merge ska tillämpa ändringarna som har hämtats i ditt arkiv eller gren.
Så nu kan du noggrant övervaka filerna innan du slår ihop dem till ditt arkiv. Och du kan också ändra D om det behövs på grund av Modified C.
2. Git Pull- Detta kommer att uppdatera din lokala filial med ursprung / huvudfilial, dvs. det som faktiskt gör är en kombination av Git Fetch och Git-sammanslagning efter varandra.
Men detta kan orsaka konflikter, så det rekommenderas att du använder Git Pull med en ren kopia.
|
Vi säger helt enkelt:
git pull == git fetch + git merge
Om du kör git pull behöver du inte slå samman data till lokalt. Om du kör git fetch betyder det att du måste köra git merge för att få den senaste koden till din lokala maskin. I annat fall ändras inte den lokala maskinkoden utan sammanslagning.
Så i Git Gui, när du hämtar, måste du slå samman data. Hämtning själv gör inte kodändringarna hos din lokala. Du kan kontrollera det när du uppdaterar koden genom att hämta
en gång hämta och se; koden ändras inte. Sedan slår du samman ... Du kommer att se den ändrade koden.
|
git fetch drar ner koden från fjärrservern till dina spårningsgrenar i ditt lokala arkiv. Om din fjärrkontroll heter origin (standard) kommer dessa filialer att ligga inom origin /, till exempel origin / master, origin / mybranch-123, etc. Dessa är inte dina nuvarande filialer, de är lokala kopior av dessa filialer från servern .
git pull gör en git-hämtning men slår sedan också samman koden från spårningsgrenen till din strömlokal version av filialen. Om du inte är redo för ändringarna ännu, bara hämta först.
|
git fetch hämtar fjärrgrenar så att du kan git diff eller git slå dem samman med den aktuella grenen. git pull körs hämta på fjärrkontrollen som spåras av den aktuella grenen och slår sedan samman resultatet. Du kan använda git fetch för att se om det finns några uppdateringar till fjärrgrenen utan att behöva slå samman dem med din lokala filial.
|
Git Fetch
Du laddar ner ändringar till din lokala filial från ursprung till hämtning. Fetch frågar fjärrkontrollen för alla åtaganden som andra har gjort men du har inte på din lokala repo. Fetch hämtar dessa åtaganden och lägger till dem i det lokala förvaret.
Git Merge
Du kan tillämpa ändringar som hämtats via hämtning med kommandot Merge. Sammanfogning tar de åtaganden som hämtas från hämtningen och försöker lägga till dem i din lokala filial. Sammanfogningen kommer att behålla engagemangshistoriken för dina lokala ändringar så att när du delar din filial med push, kommer Git att veta hur andra kan slå samman dina ändringar.
Git Pull
Hämta och slå samman tillräckligt ofta tillsammans för att ett kommando som kombinerar de två, dra, skapades. Pull gör en hämtning och sedan en sammanslagning för att lägga till de nedladdade åtagandena i din lokala filial.
|
Enkelt uttryckt, om du skulle hoppa in på ett plan utan någon internetanslutning ... innan du åkte kunde du bara göra git-hämta ursprung . Det skulle hämta alla ändringar i din dator, men hålla den separat från din lokala utveckling / arbetsyta.
På planet kan du göra ändringar i din lokala arbetsyta och sedan slå samman den med vad du har hämtat och lösa potentiella sammanslagningskonflikter allt utan en anslutning till Internet. Och om inte någon hade gjort nya ändringar i fjärrförvaret, skulle du när du anländer till destinationen göra git push-ursprung och hämta ditt kaffe.
Från denna fantastiska Atlassian-handledning:
Kommandot git fetch hämtar åtaganden, filer och refs från a
fjärrförvar till ditt lokala förvar.
Att hämta är vad du gör när du vill se vad alla andra har
arbetat med. Det liknar SVN-uppdateringen genom att det låter dig se
hur den centrala historien har utvecklats, men den tvingar dig inte till det
faktiskt slå samman ändringarna i ditt arkiv. Git isolat
hämtat innehåll som från befintligt lokalt innehåll, har det absolut
ingen effekt på ditt lokala utvecklingsarbete. Hämtat innehåll måste uttryckligen checkas ut med kommandot git checkout. Detta gör
hämta ett säkert sätt att granska åtaganden innan du integrerar dem med
ditt lokala förvar.
När du laddar ner innehåll från ett fjärrförvar finns git pull- och git-hämtningskommandon tillgängliga för att utföra uppgiften. Du kan överväga
hämta den "säkra" versionen av de två kommandona. Det kommer att ladda ner
fjärrinnehållet, men uppdatera inte ditt lokala förråds fungerande tillstånd,
lämnar ditt nuvarande arbete intakt. git pull är ju mer aggressivt
alternativ, kommer det att ladda ner fjärrinnehållet för den aktiva lokala
filial och omedelbart utföra git merge för att skapa en merge commit
för det nya fjärrinnehållet. Om du har pågående ändringar pågår
detta kommer att orsaka konflikter och starta konfliktlösning
flöde.
Med git pull:
Du får ingen isolering.
Det behöver inte checkas ut uttryckligen. Eftersom det implicit går en git samman.
Sammanfogningssteget påverkar din lokala utveckling och kan orsaka konflikter
Det är i princip INTE säkert. Det är aggressivt.
Till skillnad från git-hämtning där det bara påverkar dina .git / refs / fjärrkontroller, påverkar git pull både dina .git / refs / fjärrkontroller och .git / refs / huvuden /
Hmmm ... så om jag inte uppdaterar arbetskopian med git-hämtning, var gör jag då ändringar? Var lagrar Git de nya åtagandena?
Stor fråga. Det sätter det någonstans isolerat från din arbetskopia. Men var igen? Låt oss ta reda på.
I din projektkatalog (dvs. där du gör dina git-kommandon) gör:
ls. Detta visar filerna och katalogerna. Inget coolt, jag vet.
Gör nu ls -a. Detta visar punktfiler, dvs. filer som börjar med. Du kommer då att kunna se en katalog som heter: .git.
Gör cd .git. Detta kommer självklart att ändra din katalog.
Nu kommer den roliga delen; gör ls. Du kommer att se en lista över kataloger. Vi letar efter ref. Gör cd-ref.
Det är intressant att se vad som finns i alla kataloger, men låt oss fokusera på två av dem. huvuden och fjärrkontroller. Använd cd för att kolla in dem också.
Alla git-hämtningar du gör uppdaterar objekt i katalogen /.git/refs/remotes. Det uppdaterar ingenting i katalogen /.git/refs/heads.
Varje git pull gör först git-hämtningen, uppdaterar objekt i katalogen /.git/refs/remotes, slår sedan samman med din lokala och byter sedan huvudet i katalogen /.git/refs/heads.
Ett mycket bra relaterat svar kan också hittas i Var placerar 'git hämta' sig själv ?.
Leta också efter "Slash notation" från Git-grenens namnkonventionspost. Det hjälper dig att bättre förstå hur Git placerar saker iolika kataloger.
Att se den faktiska skillnaden
Bara gör:
git fetch origin master
git checkout master
Om fjärrmästaren uppdaterades får du ett meddelande så här:
Din filial står bakom "origin / master" med två åtaganden och kan snabbt vidarebefordras.
(använd "git pull" för att uppdatera din lokala filial)
Om du inte hämtade och bara gjorde git checkout master så skulle din lokala git inte veta att det finns två åtaganden tillagda. Och det skulle bara säga:
Redan på 'master'
Din filial är uppdaterad med "origin / master".
Men det är föråldrat och felaktigt. Det beror på att git ger dig feedback enbart baserat på vad den vet. Det är omedvetet om nya åtaganden att det inte har dragit ner ännu ...
Finns det något sätt att se de nya ändringarna i fjärrkontrollen när du arbetar lokalt?
Vissa IDE: er (t.ex. Xcode) är supersmarta och använder resultatet av en git-hämtning och kan kommentera de kodrader som har ändrats i fjärrgrenen i din nuvarande arbetsgren. Om den raden har ändrats av både lokala ändringar och fjärrgren, antecknas den raden med rött. Detta är inte en sammanslagningskonflikt. Det är en potentiell sammanslagningskonflikt. Det är en headsup som du kan använda för att lösa den framtida sammanslagningskonflikten innan du gör git pull från den avlägsna grenen.
Roligt tips:
Om du hämtade en avlägsen gren, t.ex. gjorde:
git hämtningsfunktion / 123
Då skulle detta gå in i din fjärrkatalog. Det är fortfarande inte tillgängligt för din lokala katalog. Det förenklar dock din utcheckning till den avlägsna grenen av DWIM (gör vad jag menar):
git checkout-funktion / 123
du behöver inte längre göra:
git checkout -b funktion / 123 ursprung / funktion / 123
Läs mer om det här
|
Den enda skillnaden mellan git pull och git hämtning är att:
git pull drar från en avlägsen gren och slår ihop den.
git hämtar bara hämtningar från den avlägsna grenen men den går inte ihop
dvs git pull = git fetch + git merge ...
|
Git tillåter att kronologiskt äldre åtaganden tillämpas efter nyare åtaganden.
På grund av detta delas uppförandet av förpliktelser mellan förvar i två steg:
Kopiering av nya åtaganden från fjärrgren till kopia av denna avlägsna gren inuti lokal repo.
(repo to repo operation) master @ remote >> remote / origin / master @ local
Integrera nya åtaganden till den lokala filialen
(drift inom repo) remote / origin / master @ local >> master @ local
Det finns två sätt att göra steg 2. Du kan:
Gaffel lokal gren efter sista gemensamma förfader och lägg till nya åtaganden parallellt med åtaganden som är unika för lokalt förvar, slutförda genom att slå samman engagemang, stänga gaffeln.
Infoga nya åtaganden efter den sista gemensamma förfädern och använd igen åtaganden som är unika för det lokala förvaret.
I git-terminologi är steg 1 git-hämtning, steg 2 är git merge eller git rebase
git pull är git fetch och git merge
|
Git hämtar grenen av den senaste versionen från fjärrkontrollen till den lokala med två kommandon:
git fetch: Git kommer att få den senaste versionen från fjärrkontroll till lokal, men den slås inte automatiskt samman.
git fetch origin master
git log -p master..origin / master
git merge origin / master
Kommandona ovan betyder att ladda ner senaste versionen av huvudgrenen från ursprung från fjärrkontrollen till ursprungsgrenen. Och jämför sedan den lokala huvudgrenen och ursprungsgrenen. Slutligen slå samman.
git pull: Git kommer att hämta den senaste versionen från fjärrkontrollen och gå samman med den lokala.
git pull origin master
Kommandot ovan motsvarar git-hämtning och git-sammanslagning. I praktiken kan git hämta kanske säkrare för innan sammanslagningen kan vi se ändringarna och besluta om vi ska slå samman.
|
Vad är skillnaden mellan git pull och git fetch?
För att förstå detta måste du först förstå att din lokala git inte bara underhåller ditt lokala förråd utan det underhåller också en lokal kopia av fjärrförvaret.
git fetch uppdaterar din lokala kopia av fjärrförvaret. Till exempel, om ditt fjärrförvar är GitHub - kanske du vill hämta alla ändringar som gjorts i fjärrförvaret till din lokala kopia av det fjärrförvaret. Detta gör att du kan utföra operationer som att jämföra eller slå ihop.
git pull å andra sidan tar ner ändringarna i fjärrförvaret där du behåller din egen kod. Normalt gör git pull en git-hämtning först för att uppdatera den lokala kopian av fjärrförvaret, och sedan slår det samman ändringarna i ditt eget kodförvar och eventuellt din arbetskopia.
|
git pull == (git fetch + git merge)
git fetch ändras inte till lokala filialer.
Om du redan har ett lokalt arkiv med en fjärrinställning för det önskade projektet kan du ta tag i alla grenar och taggar för den befintliga fjärrkontrollen med git-hämtning. ... Fetch gör inga ändringar i lokala filialer, så du måste slå samman en avlägsen filial med en ihopkopplad lokalfilial för att införliva nya hämtningsändringar. från github
|
En enkel grafisk representation för nybörjare,
här,
git pull
hämtar kodfrån förråd och omstart med din lokala ... i git pull finns det möjlighet att nya åtaganden skapas.
men i ,
git hämta
kommer att hämta kod från förvaret och vi måste starta om den manuellt med git rebase
t.ex.: Jag ska hämta från servermastern och basera om den i min lokala master.
1) git pull (rebase görs automatiskt):
git pull origin master
här är ursprunget ditt fjärranslutna repomästare är din gren
2) git-hämtning (måste startas om manuellt):
git fetch origin master
det hämtar serverändringar från ursprung. och det kommer att finnas i din lokal tills du omformulerar det på egen hand. vi måste åtgärda konflikter manuellt genom att kontrollera koder.
git rebase-ursprung / master
detta kommer att återkoda koden till lokal. innan det se till att du är i rätt gren.
|
Försöker vara tydlig och enkel.
Git pull-kommandot är faktiskt en genväg för git-hämtning följt av git merge eller git rebase-kommandot beroende på din konfiguration. Du kan konfigurera ditt Git-arkiv så att git pull är en hämtning följt av en rebase.
|
Egentligen underhåller Git en kopia av din egen kod och
fjärrförvaret.
Kommandot git fetch gör din lokala kopia uppdaterad genom att hämta data från fjärrförvaret. Anledningen till att vi behöver detta är att någon annan kan ha gjort några ändringar i koden och du vill hålla dig uppdaterad.
Kommandot git pull tar ändringarna i fjärrförvaret dit du behåller din egen kod. Normalt gör git pull detta genom att göra en "git-hämtning" först för att uppdatera den lokala kopian av fjärrförvaret och sedan sammanför ändringarna i ditt eget kodförråd och eventuellt din arbetskopia.
|
1
2
Nästa
Mycket aktiv fråga. Tjäna 10 rykte för att svara på den här frågan. Kravet på rykte hjälper till att skydda denna fråga från skräppost och icke-svar-aktivitet.
Inte svaret du letar efter? Bläddra bland andra frågor taggade git version-control git-pull git-hämta eller ställ din egen fråga.